bondscell_results$3be5ecc9-58cf-457a-a5d4-c9ff6114ba01queued¤logsrunning¦outputbody Using Macros
Creation
Defining a macro is like defining a function. For example,
julia> macro sayhello(name)
return :( println("Hello", $name))
end
@sayhello (macro with 1 method)
Now invoke the @sayhello macro.
julia> @sayhello("world")
Helloworld
Parentheses around the arguments are optional.
julia> @sayhello "world"
Helloworld
Note
When using the parenthesized form, there should be no space between the macro name and the parentheses. Otherwise the argument list will be interpreted as a single argument containing a Tuple.
Usage
Macros can be used for many tasks such as performing operations on blocks of code, such as timing expressions (@time), threading for loops (@threads), and converting expressions to broadcast form (@.). Another use is to generate code. When a significant amount of repetitive boilerplate code is required, it is common to generate it programmatically to avoid redundancy.
Consider the following example.
julia> struct MyNumber
x::Float64
end
We want to add a various methods to it. This can be done programmatically using a for loop.
julia> length(methods(sin))
14
julia> for op = (:sin, :tan, :log, :exp)
eval(quote
Base.$op(a::MyNumber) = MyNumber($op(a.x))
end)
end
julia> length(methods(sin))
15
A slightly shorter version of the above code generator that use the : prefix is:
julia> for op = (:sin, :cos, :tan, :log, :exp)
eval(:(Base.$op(a::MyNumber) = MyNumber($op(a.x))))
end
An even shorter version of the code uses the @eval macro.
julia> for op = (:sin, :cos, :tan, :log, :exp)
@eval Base.$op(a::MyNumber) = MyNumber($op(a.x))
end
For longer blocks of generated code, the @eval macro can proceed a code block:
julia> @eval begin
# multiple lines
end
The : Operator
The : character has two syntatic purposes in Julia. It defines a Symbol or a Quote.
Symbols
A Symbol is an interned string used as a building-block of an expression.
julia> sym = :foo
:foo
julia> typeof(sym)
Symbol
julia> sym == Symbol("foo")
true
The Symbol constructor takes a variable number of arguments and concatenates them together to create a Symbol string.
julia> Symbol("func", 10)
:func10
In the context of expressions, symbols are used to indicate access to variables. When an expression is evaluated, a symbol is replaced with the value bound to that symbol in the appropriate scope.
Quoting
The second purpose of the : character is to create expression objects without using the explicit Expr constructor. This is referred to as quoting.
julia> ex3 = :(3 * 4 + 5)
:(3 * 4 + 5)
julia> dump(ex3)
Expr
head: Symbol call
args: Array{Any}((3,))
1: Symbol +
2: Expr
head: Symbol call
args: Array{Any}((3,))
1: Symbol *
2: Int64 3
3: Int64 4
3: Int64 5
julia> ex1 == ex2 == ex3
true
So, there are three ways to construct an expression allowing the programmer to use whichever one is most convenient.
There is a second syntatic form of quoting, called a quote block (i.e. quote ... end), that is commonly used for multiple expressions. For example:
julia> ex4 = quote
x = 1
y = 2
x + y
end
quote
#= REPL[78]:2 =#
x = 1
#= REPL[78]:3 =#
y = 2
#= REPL[78]:4 =#
x + y
end
julia> typeof(ex4)
Expr
Interpolation
Julia allows interpolation of literals or expressions into quoted expressions by prefixing a variable with the $ character. For example:
julia> a = 1;
julia> ex5 = :($a + b)
:(1 + b)
julia> dump(ex5)
Expr
head: Symbol call
args: Array{Any}((3,))
1: Symbol +
2: Int64 1
3: Symbol b
Splatting is also possible.
julia> args = [:x, :y, :x];
julia> dump(:(f(1, $(args...))))
Expr
head: Symbol call
args: Array{Any}((5,))
1: Symbol f
2: Int64 1
3: Symbol x
4: Symbol y
5: Symbol x
Expression evaluation
Julia will evalution an expression in the global scope using eval.
julia> eval(ex1)
17
Note
Unlike Python, the use of eval in Julia is strongly discouraged.
Problems
Remember that you can get help either through `?` in a REPL or with "Live Docs" right here in Pluto (lower right-hand corner)
Why Macros
Unlike other interactive languages, such as Matlab, Python, and R, Julia has macros. They are a very powerful programming construct. Macros modify existing source code or generate entirely new code. In essence, they simplify programming by automating mundane coding tasks.
Preprocessor "macro" systems, like that of C/C++, work at the source code level by perform textual manipulation and substitution before any parsing or interpretation is done. For example the following C/C++ macro expression tells the compiler to insert the code between the #if and #endif statements when NAME is defined.
#if defined(NAME) ... #endif
Whereas, Julia macros work at the level of the abstract syntax tree after parsing, but before compilation is done.
2-2: Using Macros
Last Updated: 2 May 2026
The Abstract Syntax Tree
Nearly all computer languages use an abstract syntax tree (AST) to parse the syntax of the language. In other words, the strings of characters that humans can read must be converted to a language that computers can read. The following snippet of Julia code represents how that is performed. The first line creates a string expression. The second line parses that expression, the third line prints the type of the parsed expression, namely an Expr type, and the fourth line prints the AST.
The Meta.parse statement in line 2 converts the mathematical expression in line 1 into an AST.
julia> str1 = "3 * 4 + 5"
"3 * 4 + 5"
julia> ex1 = Meta.parse(str1)
:(3 * 4 + 5)
julia> typeof(ex1)
Expr
Let's dump or print the AST of the above expression.
julia> dump(ex1)
Expr
head: Symbol call
args: Array{Any}((3,))
1: Symbol +
2: Expr
head: Symbol call
args: Array{Any}((3,))
1: Symbol *
2: Int64 3
3: Int64 4
3: Int64 5
The Expr type has two fields, a head and an args. The head declares the item is a function call of type Symbol and the args is an Array of function arguments, namely the + operator of type Symbol and the two values to be added. The first value is another Expr type and the second is a 64-bit integer. The second nested Expr is also composed of a Symbol call. Its arguments are the multiplication * operation of type Symbol and two 64-bit integers. Note that the multiplication operation is nested in the addition operation, since multiplication has precedence over addition.
Note that the expression ex1 can be written directly in AST syntax.
julia> ex2 = Expr(:call, :+, Expr(:call, :*, 3, 4), 5)
:(3 * 4 + 5)
julia> dump(ex2)
Expr
head: Symbol call
args: Array{Any}((3,))
1: Symbol +
2: Expr
head: Symbol call
args: Array{Any}((3,))
1: Symbol *
2: Int64 3
3: Int64 4
3: Int64 5
julia> ex1 == ex2
true
Note
If you prefer writing code as an AST, you can do so in Julia.
However, you may not be popular with other coders.